extends Node2D

# 游戏主控制器
# 管理HUD与游戏逻辑的交互

# 引用游戏对象
@onready var player: CharacterBody2D = $Player
@onready var game_hud: GameHUD = $GameHUD
@onready var dungeon_generator = $DungeonGenerator  # 地牢生成器引用
@onready var enemy_manager: EnemyManager = $EnemyManager  # 敌人管理器引用

# 游戏状态
var game_started: bool = false
var game_paused: bool = false
var enemies: Array[BaseEnemy] = []  # 兼容性数组，现在由敌人管理器管理
var current_dungeon_rooms: Array = []  # 当前地牢的房间
var current_spawn_points: Array[Vector2i] = []  # 当前地牢的生成点
var is_restarting: bool = false  # 标记是否正在重新开始游戏

func _ready():
	# 设置游戏节点组，方便其他组件查找
	add_to_group("game")
	
	# 设置玩家组，方便HUD查找
	player.add_to_group("player")
	
	# 先隐藏玩家，直到地牢生成完成
	if player:
		player.visible = false
		print("🫥 玩家已隐藏，等待地牢生成完成")
	
	# 连接地牢生成器信号
	setup_dungeon_connections()
	
	# 初始化敌人管理器
	setup_enemy_manager()
	
	# 生成初始地牢
	generate_initial_dungeon()
	
	# 连接HUD信号
	setup_hud_connections()
	
	# 初始化HUD数据（但不显示）
	initialize_hud_data()
	
	# 连接玩家信号
	setup_player_connections()
	
	# 暂停游戏，等待开始
	pause_game_logic()

func setup_dungeon_connections():
	print("🔍 正在查找DungeonGenerator节点...")
	
	# 尝试多种方式获取DungeonGenerator节点
	var dg_node = get_node_or_null("DungeonGenerator")
	if not dg_node:
		print("❌ 通过相对路径未找到DungeonGenerator节点")
		# 尝试其他路径
		dg_node = get_parent().get_node_or_null("DungeonGenerator") if get_parent() else null
		if dg_node:
			print("✅ 在父节点中找到DungeonGenerator")
			dungeon_generator = dg_node
	else:
		print("✅ 成功找到DungeonGenerator节点")
		dungeon_generator = dg_node
	
	if dungeon_generator:
		print("🔗 连接地牢生成器信号...")
		if dungeon_generator.has_signal("dungeon_generated"):
			dungeon_generator.dungeon_generated.connect(_on_dungeon_generated)
			print("✅ 地牢生成器信号连接完成")
		else:
			print("❌ DungeonGenerator没有dungeon_generated信号")
	else:
		print("❌ DungeonGenerator节点未找到")
		print("🔍 当前节点子节点列表:")
		for child in get_children():
			print("  - ", child.name, " (", child.get_class(), ")")

func generate_initial_dungeon():
	print("🏗️ 生成初始地牢...")
	if dungeon_generator:
		# 使用随机种子生成地牢
		dungeon_generator.seed_value = 0  # 0表示使用随机种子
		dungeon_generator.generate_dungeon()
	else:
		print("❌ 无法生成地牢：DungeonGenerator未找到")

func _on_dungeon_generated(rooms: Array, spawn_points: Array[Vector2i]):
	print("🎉 地牢生成完成回调")
	print("📊 生成的房间数量: ", rooms.size())
	print("📍 生成点数量: ", spawn_points.size())
	
	current_dungeon_rooms = rooms
	current_spawn_points = spawn_points
	
	# 更新玩家的边界设置（基于新生成的地牢）
	if player and is_instance_valid(player) and player.has_method("setup_screen_bounds"):
		player.setup_screen_bounds()
		print("🗺️ 玩家边界已更新为地牢范围")
	
	# 更新所有敌人的边界设置
	for enemy in enemies:
		if enemy and is_instance_valid(enemy) and enemy.has_method("setup_screen_bounds"):
			enemy.setup_screen_bounds()
	print("🗺️ 敌人边界已更新为地牢范围")
	
	# 将玩家移动到第一个生成点
	if spawn_points.size() > 0 and dungeon_generator:
		var player_spawn = dungeon_generator.get_player_spawn_point()
		if player and is_instance_valid(player):
			player.global_position = player_spawn
			player.visible = true  # 现在可以显示玩家了
			
			# 如果是重新开始游戏，确保玩家外观和状态完全正确
			if is_restarting:
				print("🔄 重新开始游戏中，完整重置玩家状态...")
				
				# 确保玩家状态正确
				player.is_dead = false
				player.current_health = player.max_health
				
				# 重置玩家外观
				if player.sprite:
					player.sprite.modulate = Color.WHITE
					player.sprite.rotation = 0
					player.sprite.scale = Vector2(1, 1)
					player.sprite.flip_h = false
					player.sprite.texture = player.idle_texture
				
				# 重置武器和特效
				if player.weapon_sprite:
					player.weapon_sprite.visible = false
				if player.slash_effect:
					player.slash_effect.visible = false
				
				# 重置动画
				if player.animation_player:
					player.animation_player.play("idle")
				
				# 更新血条
				if player.health_bar:
					player.health_bar.set_health(player.current_health, player.max_health)
				
				print("✅ 玩家状态完全重置: 死亡=", player.is_dead, " 血量=", player.current_health)
			
			print("📍 玩家移动到生成点: ", player_spawn)
			print("👁️ 玩家现在可见")
		else:
			print("❌ 玩家节点无效，无法移动到生成点")
	else:
		print("❌ 没有生成点或地牢生成器无效")
		# 如果没有生成点，使用地图中心作为备用位置
		if player and is_instance_valid(player) and dungeon_generator and dungeon_generator.tilemap:
			var map_center = get_map_center_position()
			player.global_position = map_center
			player.visible = true
			
			# 如果是重新开始游戏，确保玩家状态正确
			if is_restarting and player.is_dead:
				player.is_dead = false
				player.current_health = player.max_health
			
			print("🎯 使用地图中心作为玩家位置: ", map_center)
	
	# 移除立即生成敌人的逻辑，改为在开始游戏时生成
	print("✅ 地牢生成完成，等待用户开始游戏后生成敌人")
	
	# 检查是否是重新开始游戏的情况，如果是则启动游戏逻辑
	if is_restarting:
		print("🔄 检测到重新开始游戏，启动游戏逻辑...")
		is_restarting = false  # 重置标志
		start_game_after_restart()

func start_game_after_restart():
	# 在地牢生成完成后启动游戏逻辑（用于重新开始游戏）
	print("🎮 地牢生成完成，启动重新开始的游戏...")
	
	# 生成敌人（重新开始游戏时）
	if enemy_manager and current_dungeon_rooms.size() > 0 and current_spawn_points.size() > 0:
		print("🏭 重新开始游戏：开始生成敌人...")
		enemy_manager.start_spawning(current_dungeon_rooms, current_spawn_points)
	else:
		print("❌ 重新开始游戏：无法生成敌人，缺少地牢数据")
	
	# 重新启用玩家的物理和输入处理
	if player and is_instance_valid(player):
		player.set_physics_process(true)
		player.set_process_input(true)
		print("🔧 玩家物理和输入处理已启用")
		print("🔧 玩家当前状态: 可见=", player.visible, " 死亡=", player.is_dead)
		print("🔧 玩家位置: ", player.global_position)
		print("🔧 玩家血量: ", player.current_health, "/", player.max_health)
	
	# 启动游戏逻辑
	game_started = true
	
	# 设置HUD到游戏状态
	if game_hud:
		# 确保游戏结束界面被隐藏
		game_hud.hide_game_over()
		
		game_hud.current_state = game_hud.GameState.PLAYING
		if player and is_instance_valid(player):
			game_hud.update_player_health(player.current_health, player.max_health)
		game_hud.update_player_stats(1, 0, 0)  # 重置统计
		# 显示游戏UI
		if game_hud.health_display:
			game_hud.health_display.visible = true
		if game_hud.player_stats:
			game_hud.player_stats.visible = true
		print("✅ HUD已设置为游戏状态")
	
	print("🎉 重新开始游戏完成！")

func get_map_center_position() -> Vector2:
	# 获取地图中心位置作为备用生成点
	if dungeon_generator and dungeon_generator.tilemap:
		var used_rect = dungeon_generator.tilemap.get_used_rect()
		var center_tile = used_rect.position + used_rect.size / 2
		var center_world = dungeon_generator.tilemap.map_to_local(center_tile)
		return center_world
	else:
		# 最后的备用方案
		return Vector2(240, 135)  # viewport的中心

func setup_hud_connections():
	if game_hud:
		print("🔗 连接HUD信号...")
		# 连接HUD信号
		game_hud.pause_game_requested.connect(_on_pause_game_requested)
		game_hud.resume_game_requested.connect(_on_resume_game_requested)
		game_hud.menu_requested.connect(_on_menu_requested)
		game_hud.start_game_requested.connect(_on_start_game_requested)
		game_hud.restart_game_requested.connect(_on_restart_game_requested)
		game_hud.return_to_main_menu_requested.connect(_on_return_to_main_menu_requested)
		game_hud.quit_game_requested.connect(_on_quit_game_requested)  # 连接退出游戏信号
		print("✅ HUD主要信号连接完成")
		
		# 连接物品栏信号
		if game_hud.item_inventory:
			game_hud.item_inventory.item_used.connect(_on_item_used)
			print("✅ 物品栏信号连接完成")
	else:
		print("❌ GameHUD节点未找到，无法连接信号")

func setup_player_connections():
	if player:
		# 如果玩家有健康系统，连接相关信号
		if player.has_signal("health_changed"):
			player.health_changed.connect(_on_player_health_changed)
		
		if player.has_signal("experience_gained"):
			player.experience_gained.connect(_on_player_experience_gained)
		
		if player.has_signal("coins_gained"):
			player.coins_gained.connect(_on_player_coins_gained)
		
		# 连接玩家死亡信号
		if player.has_signal("died"):
			player.died.connect(_on_player_died)
			print("✅ 玩家死亡信号连接完成")

func initialize_hud_data():
	if game_hud:
		# 初始化玩家健康状态（数据准备，但UI暂时不显示）
		game_hud.update_player_health(100, 100)
		
		# 初始化玩家统计
		game_hud.update_player_stats(1, 0, 0)
		
		# 添加一些示例物品到物品栏
		if game_hud.item_inventory:
			game_hud.item_inventory.create_sample_items()

func pause_game_logic():
	# 暂停游戏逻辑，但不暂停整个游戏树
	game_started = false
	
	# 禁用玩家输入
	if player and is_instance_valid(player):
		player.set_physics_process(false)
		player.set_process_input(false)
	
	# 禁用敌人AI - 添加安全检查
	for enemy in enemies:
		if enemy and is_instance_valid(enemy):
			enemy.set_physics_process(false)
			enemy.set_process(false)

func resume_game_logic():
	# 恢复游戏逻辑
	game_started = true
	
	# 启用玩家输入
	if player and is_instance_valid(player):
		player.set_physics_process(true)
		player.set_process_input(true)
	
	# 启用敌人AI - 添加安全检查
	for enemy in enemies:
		if enemy and is_instance_valid(enemy):
			enemy.set_physics_process(true)
			enemy.set_process(true)

func _on_start_game_requested():
	print("📥 收到开始游戏请求")
	
	# 确保游戏从干净状态开始
	print("🔄 确保游戏状态干净...")
	
	# 确保游戏树不处于暂停状态
	get_tree().paused = false
	
	# 重置游戏状态变量
	game_started = false  # 先设为false，稍后在resume_game_logic中设为true
	game_paused = false
	
	# 确保玩家状态正确
	if player and is_instance_valid(player):
		# 确保玩家状态正常
		if player.is_dead:
			player.respawn()  # 不传递固定坐标，让地牢生成器设置位置
		
		# 确保玩家可见（如果地牢已经生成）
		if current_spawn_points.size() > 0:
			player.visible = true
			print("👁️ 玩家已可见")
		else:
			player.visible = false
			print("🫥 玩家隐藏，等待地牢生成")
		
		print("✅ 玩家状态检查完成")
	
	# 生成敌人（如果地牢已经生成）
	if enemy_manager and current_dungeon_rooms.size() > 0 and current_spawn_points.size() > 0:
		print("🏭 开始生成敌人...")
		enemy_manager.start_spawning(current_dungeon_rooms, current_spawn_points)
	else:
		print("⏳ 等待地牢生成完成后再生成敌人")
	
	# 更新敌人列表（从敌人管理器获取）
	if enemy_manager:
		enemies = enemy_manager.get_spawned_enemies()
		print("✅ 敌人列表已更新，敌人数量: ", enemies.size())
	
	print("🎮 开始游戏！")
	resume_game_logic()

func _on_pause_game_requested():
	print("📥 收到暂停游戏请求")
	game_paused = true
	get_tree().paused = true
	print("✅ 游戏已暂停，get_tree().paused = ", get_tree().paused)

func _on_resume_game_requested():
	print("📥 收到恢复游戏请求")
	game_paused = false
	get_tree().paused = false
	print("✅ 游戏已恢复，get_tree().paused = ", get_tree().paused)

func _on_menu_requested():
	print("菜单请求 - 可以在这里实现主菜单逻辑")
	# 这里可以加载主菜单场景或显示游戏菜单

func _on_player_health_changed(current_health: int, max_health: int):
	if game_hud and game_started:
		game_hud.update_player_health(current_health, max_health)

func _on_player_experience_gained(experience: int):
	if game_hud and game_started:
		# 假设玩家有等级系统
		var player_level = player.get("level") if player.has_method("get") else 1
		var total_exp = player.get("experience") if player.has_method("get") else experience
		var coins = player.get("coins") if player.has_method("get") else 100
		
		game_hud.update_player_stats(player_level, total_exp, coins)

func _on_player_coins_gained(coins: int):
	if game_hud and game_started:
		var player_level = player.get("level") if player.has_method("get") else 1
		var experience = player.get("experience") if player.has_method("get") else 0
		var total_coins = player.get("coins") if player.has_method("get") else coins
		
		game_hud.update_player_stats(player_level, experience, total_coins)

func _on_item_used(item_data: Dictionary):
	if not game_started:
		return
		
	# 处理物品使用逻辑
	match item_data.get("id"):
		"potion_red":
			# 使用红色药水恢复生命值
			heal_player(25)
			print("使用了红色药水，恢复25点生命值")
		
		"key_silver":
			# 使用银钥匙
			print("使用了银钥匙")
		
		"bag_coins":
			# 使用金币袋获得金币
			add_player_coins(50)
			print("使用了金币袋，获得50金币")

func heal_player(amount: int):
	if not game_started:
		return
		
	if player and player.has_method("heal"):
		player.heal(amount)
	else:
		# 如果玩家没有heal方法，我们直接更新HUD显示
		var current_health = player.get("current_health") if player.has_method("get") else 100
		var max_health = player.get("max_health") if player.has_method("get") else 100
		current_health = min(current_health + amount, max_health)
		
		if game_hud:
			game_hud.update_player_health(current_health, max_health)

func add_player_coins(amount: int):
	if not game_started:
		return
		
	if player and player.has_method("add_coins"):
		player.add_coins(amount)
	else:
		# 简单的金币增加逻辑
		if game_hud and game_hud.player_stats:
			game_hud.player_stats.add_coins(amount)

func _on_player_died():
	print("💀 玩家死亡，游戏结束")
	
	# 停止游戏逻辑
	game_started = false
	
	# 禁用玩家和敌人 - 添加安全检查
	if player and is_instance_valid(player):
		player.set_physics_process(false)
		player.set_process_input(false)
	
	for enemy in enemies:
		if enemy and is_instance_valid(enemy) and enemy.has_method("set_physics_process"):
			enemy.set_physics_process(false)
		if enemy and is_instance_valid(enemy) and enemy.has_method("set_process"):
			enemy.set_process(false)
	
	# 显示游戏结束界面
	if game_hud:
		game_hud.show_game_over()

func _on_restart_game_requested():
	print("🔄 收到重新开始游戏请求")
	restart_game()

func _on_return_to_main_menu_requested():
	print("🏠 收到返回主菜单请求")
	return_to_main_menu()

func _on_quit_game_requested():
	print("🚪 收到退出游戏请求")
	quit_game()

func _on_enemy_died(enemy: BaseEnemy):
	print("💀 敌人死亡: ", enemy.name if enemy and is_instance_valid(enemy) else "未知敌人")
	
	# 从兼容性敌人数组中移除死亡的敌人
	if enemy in enemies:
		enemies.erase(enemy)
		print("✅ 已从兼容性敌人数组中移除死亡的敌人，剩余敌人数量: ", enemies.size())
	
	# 敌人管理器会自动处理自己的列表，这里不需要额外操作

# 注意：测试用的键盘快捷键已移除，确保游戏逻辑的正确性
# 经验值只能通过击杀怪物或游戏事件获得
func _input(event):
	# 保留必要的游戏输入处理，但移除测试快捷键
	pass 

func restart_game():
	print("🎮 重新开始游戏...")
	
	# 设置重新开始标志
	is_restarting = true
	
	# 停止当前游戏逻辑
	game_started = false
	
	# 清理现有敌人
	if enemy_manager:
		enemy_manager.clear_all_enemies()
		print("✅ 现有敌人已清理")
	enemies.clear()
	
	# 暂时隐藏玩家，等待地牢生成完成后重新定位
	if player and is_instance_valid(player):
		player.visible = false  # 隐藏玩家直到地牢生成完成
		print("🫥 玩家已隐藏，等待地牢生成完成")
	
	# 重新生成地牢（所有状态重置将在地牢生成完成回调中处理）
	if dungeon_generator:
		print("🏗️ 重新生成地牢...")
		# 使用随机种子重新生成
		dungeon_generator.seed_value = 0  # 随机种子
		dungeon_generator.generate_dungeon()
	
	print("⏳ 等待地牢生成完成后启动游戏逻辑...")

func return_to_main_menu():
	print("🏠 返回主菜单...")
	
	# 首先确保取消游戏树的暂停状态
	get_tree().paused = false
	print("✅ 游戏树暂停状态已清除")
	
	# 重置所有游戏状态
	game_started = false
	game_paused = false
	
	# 使用玩家的respawn函数重置玩家
	if player and is_instance_valid(player):
		# 重置玩家状态，但隐藏直到需要时再显示
		player.respawn()  # 不传递固定坐标
		player.visible = false  # 隐藏玩家
		player.set_physics_process(false)
		player.set_process_input(false)
		print("✅ 玩家状态已重置并隐藏")
	
	# 清理所有敌人（通过敌人管理器）
	if enemy_manager:
		enemy_manager.clear_all_enemies()
		print("✅ 敌人已通过管理器清理")
	
	# 更新兼容性敌人数组
	enemies.clear()
	
	# 返回开始界面 - 确保HUD状态完全重置
	if game_hud:
		# 先重置HUD的内部状态
		game_hud.game_paused = false
		game_hud.inventory_open = false
		# 然后设置开始界面状态
		game_hud.set_start_screen_state()
		print("✅ HUD状态已重置")
	
	print("🏠 已返回主菜单，所有状态已重置")

func quit_game():
	print("🚪 退出游戏...")
	
	# 可以在这里添加保存游戏数据的逻辑
	# save_game_data()
	
	# 显示退出确认或直接退出
	print("👋 游戏即将关闭")
	get_tree().quit() 

func setup_enemy_manager():
	print("🏭 设置敌人管理器...")
	
	if enemy_manager:
		# 初始化敌人管理器
		enemy_manager.initialize(self)
		
		# 连接敌人管理器信号
		enemy_manager.enemy_spawned.connect(_on_enemy_spawned)
		enemy_manager.all_enemies_spawned.connect(_on_all_enemies_spawned)
		enemy_manager.enemy_died.connect(_on_enemy_died)
		enemy_manager.victory_achieved.connect(_on_victory_achieved)  # 连接通关信号
		
		print("✅ 敌人管理器设置完成")
	else:
		print("❌ 敌人管理器节点未找到")

func _on_enemy_spawned(enemy: BaseEnemy):
	"""处理敌人生成事件"""
	print("👹 敌人生成: ", enemy.name)
	# 更新敌人边界设置
	if enemy and is_instance_valid(enemy) and enemy.has_method("setup_screen_bounds"):
		enemy.setup_screen_bounds()

func _on_all_enemies_spawned():
	"""所有敌人生成完成"""
	print("🎉 所有敌人生成完成")
	# 更新兼容性数组
	enemies = enemy_manager.get_spawned_enemies()

func _on_victory_achieved():
	print("🏆 通关！")
	
	# 停止游戏逻辑
	game_started = false
	
	# 禁用玩家和敌人 - 添加安全检查
	if player and is_instance_valid(player):
		player.set_physics_process(false)
		player.set_process_input(false)
	
	for enemy in enemies:
		if enemy and is_instance_valid(enemy) and enemy.has_method("set_physics_process"):
			enemy.set_physics_process(false)
		if enemy and is_instance_valid(enemy) and enemy.has_method("set_process"):
			enemy.set_process(false)
	
	# 显示通关界面
	if game_hud:
		game_hud.show_victory()
